package util;

import pojo.Person;
import pojo.PokeEnum;

import java.util.Comparator;
import java.util.List;

/**
 * 1. 同花顺 > 四条 > 三条+对子 > 同花 > 顺子 > 三条 > 两对 > 一对 > 散牌
 * 2. 黑桃 > 红心 > 梅花 > 方块
 * 3. A > K > Q > J > 10 > 9 > ... > 2
 * 4. (A K Q J 10)可以，（5 4 3 2 A）也可以
 * 5. 比较的时候先比较牌型，再比较数字，再比较花色
 */
public class PokeComparator {
    /**
     * 判断出谁获胜，即谁能够获胜
     */
    public static int getWinner(List<Person> gamer){
        int[] score = new int[gamer.size()];
        int maxIndex = 0;
        int maxScore = 0;

        //找出得分最高者的下标
        for (int i=0; i<gamer.size() ; i++){
            if (gamer.get(i).isAbandon()){
                //放弃者得0分
                score[i] = 0;
            }else {
                score[i] = getScore(gamer.get(i).getPokeList());
            }
            if (maxScore < score[i]){
                maxScore = score[i];
                maxIndex = i;
            }
        }
        return maxIndex;
    }

    /**
     * 得到某个人牌的得分
     * 牌型对应分数为 同花顺8000000 四条7000000 三条+对子6000000 ...
     * 牌型+最大的一张牌的分数为总得分
     * @param pokeEnumList
     * @return
     */
    public static int getScore(List<PokeEnum> pokeEnumList){
        //把牌先按照index进行升序排序
        pokeEnumList.sort(Comparator.comparingInt(PokeEnum::getIndex));

        //把每一个值除4，得到该扑克牌的大小
        int[] values = {((pokeEnumList.get(0).getIndex()-1)/4+2),((pokeEnumList.get(1).getIndex()-1)/4+2),
                ((pokeEnumList.get(2).getIndex()-1)/4+2),((pokeEnumList.get(3).getIndex()-1)/4+2),
                ((pokeEnumList.get(4).getIndex()-1)/4+2)};

        //从大到小调用函数进行计算得分
        int straightFlush = checkStraightFlush(pokeEnumList,values);
        if (straightFlush != 0){
            return straightFlush;
        }
        int boom = checkBoom(values);
        if (boom != 0){
            return boom;
        }
        int threePair = checkThreePair(values);
        if (threePair != 0){
            return threePair;
        }
        int flush = checkFlush(pokeEnumList);
        if (flush != 0){
            return flush;
        }
        int straight = checkStraight(pokeEnumList,values);
        if (straight != 0){
            return straight;
        }
        int three = checkThree(values);
        if (three != 0){
            return three;
        }
        int twoPair = checkTwoPair(pokeEnumList,values);
        if (twoPair != 0) {
            return twoPair;
        }
        int pair = checkPair(pokeEnumList,values);
        if (pair != 0){
            return pair;
        }
        return checkMaxSingle(pokeEnumList);
    }
    /**
     * 检查是否为同花顺
     * @param pokeEnumList
     * @return
     */
    private static int checkStraightFlush(List<PokeEnum> pokeEnumList,int[] values){
        //判断是否为顺子
        int straight = checkStraight(pokeEnumList,values);
        if (straight != 0){
            //判断是否为同花
            int flush = checkFlush(pokeEnumList);
            if (flush != 0){
                return 8000000+flush;
            }else {
                return 0;
            }
        }else {
            return 0;
        }
    }

    /**
     * 检查是否为四条
     */
    private static int checkBoom(int[] values){
        if (values[0] == values[3]){
            return 7000000+values[3];
        }
        if (values[1] == values[4]){
            return 7000000+values[4];
        }
        return 0;
    }

    /**
     * 检查是否为三条加对子
     */
    private static int checkThreePair(int[] values){
        if (values[0] == values[2] && values[3] == values[4]){
            return 6000000+values[2];
        }
        if (values[2] == values[4] && values[0] == values[1]){
            return 6000000+values[4];
        }
        return 0;
    }

    /**
     * 检查是否为同花
     */
    private static int checkFlush(List<PokeEnum> pokeEnumList){
        String color = pokeEnumList.get(0).getColor();
        if (pokeEnumList.get(1).getColor().equals(color)
            && pokeEnumList.get(2).getColor().equals(color)
            && pokeEnumList.get(3).getColor().equals(color)
            && pokeEnumList.get(4).getColor().equals(color)){
            return 5000000+pokeEnumList.get(4).getIndex();
        }
        return 0;
    }


    /**
     * 检查是否为顺子,返回最大的index
     */
    private static int checkStraight(List<PokeEnum> pokeEnumList,int[] values){

        //判断（5 4 3 2 A）这种特殊情况
        if (pokeEnumList.get(4).getName().equals("5") &&
            pokeEnumList.get(3).getName().equals("4") &&
            pokeEnumList.get(2).getName().equals("3") &&
            pokeEnumList.get(1).getName().equals("2") &&
            pokeEnumList.get(0).getName().equals("A") ){
            return 4000000+pokeEnumList.get(4).getIndex();
        }

        if (values[0] + 1 == values[1] &&
            values[1] + 1 == values[2] &&
            values[2] + 1 == values[3] &&
            values[3] + 1 == values[4] ){
            return 4000000+pokeEnumList.get(4).getIndex();
        }else {
            return 0;
        }
    }

    /**
     * 检查是否为三条+散牌
     */
    private static int checkThree(int[] values){
        if (values[0] == values[2]){
            return 3000000+values[2];
        }
        if (values[1] == values[3]){
            return 3000000+values[3];
        }
        if (values[2] == values[4]){
            return 3000000+values[4];
        }
        return 0;
    }

    /**
     * 检查是否为两对
     */
    private static int checkTwoPair(List<PokeEnum> pokeEnumList,int[] values){
        if (values[0] == values [1] && values[2] == values[3]){
            return 2000000+values[1]*10000+values[2]*100+pokeEnumList.get(4).getIndex();
        }
        if (values[0] == values [1] && values[3] == values[4]){
            return 2000000+values[1]*10000+values[3]*100+pokeEnumList.get(2).getIndex();
        }
        if (values[1] == values [2] && values[3] == values[4]){
            return 2000000+values[1]*10000+values[3]*100+pokeEnumList.get(0).getIndex();
        }
        return 0;
    }

    /**
     * 检查是否为一对
     */
    private static int checkPair(List<PokeEnum> pokeEnumList,int[] values){
        for (int i = 0 ; i < 3 ; i++){
            if (values[i] == values[i+1]){
                return 1000000+values[i]*100+pokeEnumList.get(4).getIndex();
            }
        }
        if (values[3] == values[4]){
            return 1000000+values[3]*100+pokeEnumList.get(2).getIndex();
        }
        return 0;
    }

    private static int checkMaxSingle(List<PokeEnum> pokeEnumList){
        return pokeEnumList.get(4).getIndex();
    }
}
